Lambda the Ultimate

Haskell' (pronounced "Haskell prime") is being formulated while we sleep. While the committee wants to incorporate into the new standard only "tried-and-true language features", a quick glance at the mailing list shows quite a few unimplemented ideas being tossed around.

The same thing happens with the C++ standardization process. Is it a good idea to keep language standardization conservative? Herb Sutter would perhaps argue so, since the export feature in C++98 was so rarely implemented.

So, is conservatism right for C++0x? Is it right for Haskell'?

The essence of ML type inference is an expanded version of Chapter 10 of the beloved Advanced Topics in Types and Programming Languages. It weighs in as the heaviest non-dissertation, non-book academic paper I've ever seen, but it's still a great introduction to HM type inference with some extensions.

The extensions are based on contraints, and are closely related to HM(X) and Chameleon. Along the way, the authors deal with row types, equirecursive types, and subtyping. Fun for the whole family!

I didn't see anyone post them yet, so here are the slides from Tim Sweeney's POPL talk entitled "The Next Mainstream Programming Languages: A Game Developer's Perspective". I know Tim and I aren't the only game developers who follow LtU, and I figure even non-game developers might find them quite interesting!

http://www.cs.princeton.edu/~dpw/popl/06/Tim-POPL.ppt

The ACM has named 34 new Fellows for 2005, one of whom is Robert Harper, "for contributions to type systems for programming languages." This recognition is certainly well deserved, and Harper's work has been discussed here many times.

Here is the official ACM press release.

The Naked Objects Approach is not a sleazy way to make a quick buck, but a framework for writing business applications that does away with the usual Model-View-Controller architecture. To quote the website:

In the naked objects approach ... writing a business application implies writing only the business domain objects themselves. All business functionality is implemented as behaviours or methods on those objects - the objects can be described as being 'behaviourally complete'. These business objects are then presented directly and automatically to the user, by means of a completely generic viewing mechanism. Similarly, the persistence layer can be generated completely automatically from the domain object definitions (manual mapping will still be required if the objects must interface with existing databases).

Sounds like polytypic programming to me! Ruby on Rails has something similar with scaffolding, and the Django framework in Python does the same.

It's nice to see application of theory, though I'm virtually certain those doing the applying wouldn't recognise it as such.

PyPy, the Python implementation written in Python, was mentioned here a couple of times in the past. After it was mentioned in a recent LtU discussion, I took another look, and boy did they make a lot of progress when I wasn't looking. PyPy can even compile itself now... You should check it out again if you are interested in this sort of thing.

There's even an introduction to the techniques used by PyPy, including a nice (but very high level) overview of abstract interpretation.

The Rho-calculus is a calculus of pattern matching that embeds the lambda-calculus in a very simple manner, and also naturally accomodates a number of extensions of the lambda-calculus. It encodes the results of pattern matching in a manner that ensures confluence of the whole calculus.

It was proposed by Horatiu Cirstea and Claude Kirchner in 1998, and Matching Power, a 2001 RTA paper, is maybe the nicest introduction to the calculus. Kirchner's research group maintains a list of papers.

Postscript There was an LtU classic story on the rho-calculus as well...

(via Daily Python-URL)

The key idea behind MyHDL is the use of Python generators to model hardware concurrency. Generators are best described as resumable functions. In MyHDL, generators are used in a specific way so that they become similar to always blocks in Verilog or processes in VHDL.

A hardware module is modeled as a function that returns any number of generators. This approach makes it straightforward to support features such as arbitrary hierarchy, named port association, arrays of instances, and conditional instantiation.

MyHDL is an open-source package for using Python as a hardware description and verification language. A Verilog converter is also included.

EE Times provides some background on MyHDL in this article.

This seems like a nice summary of various approaches, and provides an interesting prespective on prototype based languages in general and on Javascript in particular. Some of the libraries mentioned were discussed here before.

It is tempting to compare this to various documents trying to show "how to add objects to Scheme/Haskell/etc." The solutions are rather similar...

PiDuce is a concurrent, distributed language intended for experimenting emerging Web Services technologies. PiDuce can be used as a target language for compilers and processors of business languages such as BizTalk and BPel...

PiDuce builds on solid theoretical foundations: it integrates the communication primitives of the Pi calculus, the synchronization patterns of the Join calculus, and an expressive type system that extends XML datatypes with first-class channels and that retains a notion of subtyping. PiDuce is
a type-safe language: well-typed process cannot fail.

PiDuce is implemented in C#. Source code and binaries are available for download.